நேர்த்தியின் சக்தி: ஜாவாஸ்கிரிப்ட் பேட்டர்ன் மேட்சிங் பற்றிய ஒரு ஆழமான பார்வை

பல தசாப்தங்களாக, ஜாவாஸ்கிரிப்ட் டெவலப்பர்கள் நிபந்தனை தர்க்கத்திற்காக ஒரு பழக்கமான கருவிகளின் தொகுப்பை நம்பியுள்ளனர்: மதிப்புமிக்க if/else சங்கிலி மற்றும் உன்னதமான switch ஸ்டேட்மென்ட். அவை கிளை தர்க்கத்தின் வேலைக்குதிரைகள், செயல்பாட்டு மற்றும் கணிக்கக்கூடியவை. ஆயினும்கூட, நமது பயன்பாடுகள் சிக்கலானதாக வளரும்போதும், ஃபங்ஷனல் புரோகிராமிங் போன்ற முன்னுதாரணங்களை நாம் தழுவும்போதும், இந்த கருவிகளின் வரம்புகள் பெருகிய முறையில் தெளிவாகின்றன. நீண்ட if/else சங்கிலிகளைப் படிப்பது கடினமாகிவிடும், மேலும் switch ஸ்டேட்மென்ட்கள், அவற்றின் எளிய சமத்துவ சோதனைகள் மற்றும் ஃபால்-த்ரூ வினோதங்களுடன், சிக்கலான தரவு கட்டமைப்புகளைக் கையாளும்போது பெரும்பாலும் தோல்வியடைகின்றன.

இங்குதான் பேட்டர்ன் மேட்சிங் வருகிறது. இது வெறும் 'ஸ்டீராய்டுகளில் உள்ள ஸ்விட்ச் ஸ்டேட்மென்ட்' அல்ல; இது ஒரு முன்னுதாரண மாற்றம். ஹாஸ்கல், எம்எல் மற்றும் ரஸ்ட் போன்ற ஃபங்ஷனல் மொழிகளில் இருந்து உருவான பேட்டர்ன் மேட்சிங், ஒரு மதிப்பை தொடர்ச்சியான பேட்டர்ன்களுக்கு எதிராக சரிபார்க்கும் ஒரு பொறிமுறையாகும். இது சிக்கலான தரவை சிதைக்கவும், அதன் வடிவத்தை சரிபார்க்கவும், அந்த கட்டமைப்பின் அடிப்படையில் குறியீட்டை இயக்கவும் அனுமதிக்கிறது, அனைத்தும் ஒரே, வெளிப்படையான கட்டமைப்பில். இது இம்பரேட்டிவ் சரிபார்ப்பிலிருந்து ("மதிப்பை எவ்வாறு சரிபார்ப்பது") டெக்ளரேட்டிவ் மேட்சிங்கிற்கு ("மதிப்பு எப்படி இருக்கிறது") ஒரு நகர்வு.

இந்தக் கட்டுரை, ஜாவாஸ்கிரிப்டில் இன்று பேட்டர்ன் மேட்சிங்கைப் புரிந்துகொள்வதற்கும் பயன்படுத்துவதற்கும் ஒரு விரிவான வழிகாட்டியாகும். அதன் முக்கிய கருத்துக்கள், நடைமுறை பயன்பாடுகள் மற்றும் அது ஒரு நேட்டிவ் மொழி அம்சமாக மாறுவதற்கு நீண்ட காலத்திற்கு முன்பே இந்த சக்திவாய்ந்த ஃபங்ஷனல் பேட்டர்னை உங்கள் திட்டங்களில் கொண்டு வர நூலகங்களை எவ்வாறு பயன்படுத்தலாம் என்பதை நாங்கள் ஆராய்வோம்.

பேட்டர்ன் மேட்சிங் என்றால் என்ன? ஸ்விட்ச் ஸ்டேட்மென்ட்களைத் தாண்டிச் செல்லுதல்

அதன் மையத்தில், பேட்டர்ன் மேட்சிங் என்பது தரவு கட்டமைப்புகளை உடைத்து, அவை ஒரு குறிப்பிட்ட 'பேட்டர்ன்' அல்லது வடிவத்திற்கு பொருந்துகின்றனவா என்பதைப் பார்க்கும் செயல்முறையாகும். ஒரு பொருத்தம் காணப்பட்டால், அதனுடன் தொடர்புடைய குறியீட்டின் ஒரு பிளாக்கை நாம் இயக்கலாம், பெரும்பாலும் பொருத்தப்பட்ட தரவின் பகுதிகளை அந்த பிளாக்கிற்குள் பயன்படுத்த உள்ளூர் மாறிகளுக்கு பிணைக்க முடியும்.

இதை ஒரு பாரம்பரிய switch ஸ்டேட்மென்டுடன் ஒப்பிடுவோம். ஒரு switch ஆனது கடுமையான சமத்துவ (===) சோதனைகளுக்கு ஒரு ஒற்றை மதிப்பிற்கு எதிராக கட்டுப்படுத்தப்பட்டுள்ளது:

function getHttpStatusMessage(status) {
switch (status) {
case 200:
return 'OK';
case 404:
return 'Not Found';
case 500:
return 'Internal Server Error';
default:
return 'Unknown Status';
}
}

இது எளிய, அடிப்படை மதிப்புகளுக்கு சரியாக வேலை செய்கிறது. ஆனால் ஒரு API ரெஸ்பான்ஸ் போன்ற சிக்கலான ஆப்ஜெக்டை நாம் கையாள விரும்பினால் என்ன செய்வது?

const response = { status: 'success', data: { user: 'John Doe' } };
// or
const errorResponse = { status: 'error', error: { code: 'E401', message: 'Unauthorized' } };

ஒரு switch ஸ்டேட்மென்ட் இதை நேர்த்தியாக கையாள முடியாது. நீங்கள் பண்புகளின் இருப்பு மற்றும் அவற்றின் மதிப்புகளை சரிபார்த்து, ஒரு குழப்பமான if/else ஸ்டேட்மென்ட்களின் தொடரில் தள்ளப்படுவீர்கள். இங்குதான் பேட்டர்ன் மேட்சிங் பிரகாசிக்கிறது. இது ஆப்ஜெக்ட்டின் முழு வடிவத்தையும் ஆய்வு செய்ய முடியும்.

ஒரு பேட்டர்ன் மேட்சிங் அணுகுமுறை கருத்தியல் ரீதியாக இப்படி இருக்கும் (கற்பனையான எதிர்கால தொடரியலைப் பயன்படுத்தி):

function handleResponse(response) {
return match (response) {
when { status: 'success', data: d }: `Success! Data received for ${d.user}`,
when { status: 'error', error: e }: `Error ${e.code}: ${e.message}`,
default: 'Invalid response format'
}
}

முக்கிய வேறுபாடுகளை கவனியுங்கள்:

• கட்டமைப்பு பொருத்தம் (Structural Matching): இது ஒரு ஒற்றை மதிப்பை மட்டும் அல்லாமல், ஆப்ஜெக்ட்டின் வடிவத்திற்கு எதிராக பொருந்துகிறது.
• தரவு பிணைப்பு (Data Binding): இது பேட்டர்னுக்குள் நேரடியாக `d` மற்றும் `e` போன்ற உள்ளமைக்கப்பட்ட மதிப்புகளை பிரித்தெடுக்கிறது.
• எக்ஸ்பிரஷன்-சார்ந்தது (Expression-Oriented): முழு `match` பிளாக்கும் ஒரு மதிப்பைத் தரும் எக்ஸ்பிரஷனாக உள்ளது, இது ஒவ்வொரு கிளையிலும் தற்காலிக மாறிகள் மற்றும் `return` ஸ்டேட்மென்ட்களின் தேவையை நீக்குகிறது. இது ஃபங்ஷனல் புரோகிராமிங்கின் ஒரு முக்கிய கொள்கையாகும்.

ஜாவாஸ்கிரிப்டில் பேட்டர்ன் மேட்சிங்கின் நிலை

உலகளாவிய டெவலப்பர் சமூகத்திற்கு ஒரு தெளிவான எதிர்பார்ப்பை அமைப்பது முக்கியம்: பேட்டர்ன் மேட்சிங் இன்னும் ஜாவாஸ்கிரிப்டின் ஒரு நிலையான, நேட்டிவ் அம்சம் அல்ல.

இதை ECMAScript தரத்தில் சேர்க்க ஒரு செயலில் உள்ள TC39 முன்மொழிவு உள்ளது. இருப்பினும், இதை எழுதும் நேரத்தில், இது நிலை 1-ல் உள்ளது, அதாவது இது ஆரம்ப ஆய்வு கட்டத்தில் உள்ளது. அனைத்து முக்கிய உலாவிகள் மற்றும் Node.js சூழல்களில் இது நேட்டிவ்வாக செயல்படுத்தப்படுவதைக் காண பல ஆண்டுகள் ஆகலாம்.

அப்படியானால், இன்று நாம் அதை எப்படிப் பயன்படுத்தலாம்? நாம் துடிப்பான ஜாவாஸ்கிரிப்ட் சூழல் அமைப்பை நம்பலாம். நவீன ஜாவாஸ்கிரிப்ட் மற்றும் டைப்ஸ்கிரிப்டுக்கு பேட்டர்ன் மேட்சிங்கின் சக்தியைக் கொண்டுவர பல சிறந்த நூலகங்கள் உருவாக்கப்பட்டுள்ளன. இந்தக் கட்டுரையில் உள்ள எடுத்துக்காட்டுகளுக்கு, நாம் முதன்மையாக ts-pattern ஐப் பயன்படுத்துவோம், இது ஒரு பிரபலமான மற்றும் சக்திவாய்ந்த நூலகமாகும், இது முழுமையாக தட்டச்சு செய்யப்பட்டது, மிகவும் வெளிப்படையானது, மற்றும் TypeScript மற்றும் சாதாரண ஜாவாஸ்கிரிப்ட் திட்டங்களில் தடையின்றி செயல்படுகிறது.

ஃபங்ஷனல் பேட்டர்ன் மேட்சிங்கின் முக்கிய கருத்துக்கள்

நீங்கள் சந்திக்கும் அடிப்படைக் பேட்டர்ன்களைப் பற்றி விரிவாகப் பார்ப்போம். எங்கள் குறியீட்டு எடுத்துக்காட்டுகளுக்கு ts-pattern ஐப் பயன்படுத்துவோம், ஆனால் கருத்துக்கள் பெரும்பாலான பேட்டர்ன் மேட்சிங் செயலாக்கங்களில் பொதுவானவை.

லிட்டரல் பேட்டர்ன்ஸ்: எளிமையான பொருத்தம்

இது ஒரு `switch` கேஸைப் போன்ற, மேட்சிங்கின் மிகவும் அடிப்படை வடிவமாகும். இது சரங்கள், எண்கள், பூலியன்கள், `null`, மற்றும் `undefined` போன்ற அடிப்படை மதிப்புகளுடன் பொருந்துகிறது.

import { match } from 'ts-pattern';

function getPaymentMethod(method) {
return match(method)
.with('credit_card', () => 'Processing with Credit Card Gateway')
.with('paypal', () => 'Redirecting to PayPal')
.with('crypto', () => 'Processing with Cryptocurrency Wallet')
.otherwise(() => 'Invalid Payment Method');
}

console.log(getPaymentMethod('paypal')); // "Redirecting to PayPal"
console.log(getPaymentMethod('bank_transfer')); // "Invalid Payment Method"

.with(pattern, handler) தொடரியல் மையமானது. .otherwise() கிளாஸ் ஒரு `default` கேஸின் சமமானதாகும், மேலும் பொருத்தம் முழுமையானது (அனைத்து சாத்தியக்கூறுகளையும் கையாளுகிறது) என்பதை உறுதிப்படுத்த இது பெரும்பாலும் அவசியம்.

டீஸ்ட்ரக்சரிங் பேட்டர்ன்ஸ்: ஆப்ஜெக்ட்கள் மற்றும் அரேக்களை பிரித்தல்

இங்குதான் பேட்டர்ன் மேட்சிங் தன்னை உண்மையாக வேறுபடுத்துகிறது. நீங்கள் ஆப்ஜெக்ட்கள் மற்றும் அரேக்களின் வடிவம் மற்றும் பண்புகளுடன் பொருத்தலாம்.

ஆப்ஜெக்ட் டீஸ்ட்ரக்சரிங்:

ஒரு பயன்பாட்டில் நீங்கள் நிகழ்வுகளைச் செயலாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். ஒவ்வொரு நிகழ்வும் ஒரு `type` மற்றும் ஒரு `payload` உடன் ஒரு ஆப்ஜெக்ட் ஆகும்.

import { match, P } from 'ts-pattern'; // P என்பது பிளேஸ்ஹோல்டர் ஆப்ஜெக்ட்

function handleEvent(event) {
return match(event)
.with({ type: 'USER_LOGIN', payload: { userId: P.select() } }, (userId) => {
console.log(`User ${userId} logged in.`);
// ... லாகின் பக்க விளைவுகளைத் தூண்டவும்
})
.with({ type: 'ADD_TO_CART', payload: { productId: P.select('id'), quantity: P.select('qty') } }, ({ id, qty }) => {
console.log(`Added ${qty} of product ${id} to the cart.`);
})
.with({ type: 'PAGE_VIEW' }, () => {
console.log('Page view tracked.');
})
.otherwise(() => {
console.log('Unknown event received.');
});
}

handleEvent({ type: 'USER_LOGIN', payload: { userId: 'u-123', timestamp: 1678886400 } });
handleEvent({ type: 'ADD_TO_CART', payload: { productId: 'prod-abc', quantity: 2 } });

இந்த எடுத்துக்காட்டில், P.select() ஒரு சக்திவாய்ந்த கருவியாகும். இது அந்த நிலையில் எந்த மதிப்பையும் பொருத்தும் ஒரு வைல்டு கார்டாக செயல்படுகிறது மற்றும் அதை பிணைக்கிறது, இது ஹேண்ட்லர் செயல்பாட்டிற்கு கிடைக்கிறது. நீங்கள் ஒரு விளக்கமான ஹேண்ட்லர் கையொப்பத்திற்காக தேர்ந்தெடுக்கப்பட்ட மதிப்புகளுக்கு பெயரிடலாம்.

அரே டீஸ்ட்ரக்சரிங்:

நீங்கள் அரேக்களின் கட்டமைப்பிலும் பொருத்தலாம், இது கட்டளை-வரி ஆர்குமென்ட்களைப் பிரித்தல் அல்லது டப்பிள் போன்ற தரவுகளுடன் வேலை செய்வது போன்ற பணிகளுக்கு நம்பமுடியாத அளவிற்கு பயனுள்ளதாக இருக்கும்.

function parseCommand(args) {
return match(args)
.with(['install', P.select()], (pkg) => `Installing package: ${pkg}`)
.with(['delete', P.select(), '--force'], (file) => `Force deleting file: ${file}`)
.with(['list'], () => 'Listing all items...')
.with([], () => 'No command provided. Use --help for options.')
.otherwise((unrecognized) => `Error: Unrecognized command sequence: ${unrecognized.join(' ')}`);
}

console.log(parseCommand(['install', 'react'])); // "Installing package: react"
console.log(parseCommand(['delete', 'temp.log', '--force'])); // "Force deleting file: temp.log"
console.log(parseCommand([])); // "No command provided..."

வைல்டு கார்டு மற்றும் பிளேஸ்ஹோல்டர் பேட்டர்ன்ஸ்

நாம் ஏற்கனவே P.select() ஐப் பார்த்தோம், இது பிணைக்கும் பிளேஸ்ஹோல்டர். ts-pattern ஒரு எளிய வைல்டு கார்டையும் வழங்குகிறது, P._, நீங்கள் ஒரு நிலையைப் பொருத்த வேண்டியிருக்கும்போது ஆனால் அதன் மதிப்பைப் பற்றி கவலைப்படாமல் இருக்கும்போது.

• P._ (வைல்டு கார்டு): எந்த மதிப்பையும் பொருத்துகிறது, ஆனால் அதைப் பிணைக்காது. ஒரு மதிப்பு இருக்க வேண்டும் ஆனால் நீங்கள் அதைப் பயன்படுத்த மாட்டீர்கள் என்றால் இதைப் பயன்படுத்தவும்.
• P.select() (பிளேஸ்ஹோல்டர்): எந்த மதிப்பையும் பொருத்துகிறது மற்றும் அதை ஹேண்ட்லரில் பயன்படுத்த பிணைக்கிறது.

match(data)
.with(['SUCCESS', P._, P.select()], (message) => `Success with message: ${message}`)
// இங்கே, நாம் இரண்டாவது உறுப்பைப் புறக்கணிக்கிறோம் ஆனால் மூன்றாவது உறுப்பைப் பிடிக்கிறோம்.
.otherwise(() => 'No success message');

கார்டு கிளாஸஸ்: .when() உடன் நிபந்தனை தர்க்கத்தைச் சேர்த்தல்

சில நேரங்களில், ஒரு வடிவத்தைப் பொருத்துவது மட்டும் போதாது. நீங்கள் ஒரு கூடுதல் நிபந்தனையைச் சேர்க்க வேண்டியிருக்கலாம். இங்குதான் கார்டு கிளாஸஸ் வருகின்றன. ts-pattern இல், இது .when() முறை அல்லது P.when() பிரடிகேட் மூலம் நிறைவேற்றப்படுகிறது.

ஆர்டர்களைச் செயலாக்குவதாக கற்பனை செய்து பாருங்கள். நீங்கள் உயர் மதிப்புள்ள ஆர்டர்களை வித்தியாசமாகக் கையாள விரும்புகிறீர்கள்.

function getOrderStatus(order) {
return match(order)
.with({ status: 'shipped', total: P.when(t => t > 1000) }, () => 'High-value order shipped.')
.with({ status: 'shipped' }, () => 'Standard order shipped.')
.with({ status: 'processing', items: P.when(items => items.length === 0) }, () => 'Warning: Processing empty order.')
.with({ status: 'processing' }, () => 'Order is being processed.')
.with({ status: 'cancelled' }, () => 'Order has been cancelled.')
.otherwise(() => 'Unknown order status.');
}

console.log(getOrderStatus({ status: 'shipped', total: 1500 })); // "High-value order shipped."
console.log(getOrderStatus({ status: 'shipped', total: 50 })); // "Standard order shipped."
console.log(getOrderStatus({ status: 'processing', items: [] })); // "Warning: Processing empty order."

மேலும் குறிப்பிட்ட பேட்டர்ன் (.when() கார்டுடன்) பொதுவான ஒன்றிற்கு முன் வர வேண்டும் என்பதை கவனியுங்கள். வெற்றிகரமாக பொருந்தும் முதல் பேட்டர்ன் வெற்றி பெறுகிறது.

டைப் மற்றும் பிரடிகேட் பேட்டர்ன்ஸ்

நீங்கள் தரவு வகைகளுக்கு எதிராக அல்லது தனிப்பயன் பிரடிகேட் செயல்பாடுகளுக்கு எதிராகவும் பொருத்தலாம், இது இன்னும் அதிக நெகிழ்வுத்தன்மையை வழங்குகிறது.

function describeValue(x) {
return match(x)
.with(P.string, () => 'This is a string.')
.with(P.number, () => 'This is a number.')
.with({ message: P.string }, () => 'This is an error object.')
.with(P.instanceOf(Date), (d) => `This is a Date object for ${d.getFullYear()}.`)
.otherwise(() => 'This is some other type of value.');
}

நவீன வலை மேம்பாட்டில் நடைமுறைப் பயன்பாட்டு வழக்குகள்

கோட்பாடு சிறந்தது, ஆனால் பேட்டர்ன் மேட்சிங் உலகளாவிய டெவலப்பர் சமூகத்திற்கு நிஜ-உலகப் பிரச்சினைகளை எவ்வாறு தீர்க்கிறது என்று பார்ப்போம்.

சிக்கலான API ரெஸ்பான்ஸ்களை கையாளுதல்

இது ஒரு உன்னதமான பயன்பாட்டு வழக்கு. API-கள் அரிதாகவே ஒரு ஒற்றை, நிலையான வடிவத்தை வழங்குகின்றன. அவை வெற்றி ஆப்ஜெக்ட்கள், பல்வேறு பிழை ஆப்ஜெக்ட்கள், அல்லது லோடிங் நிலைகளை வழங்குகின்றன. பேட்டர்ன் மேட்சிங் இதை அழகாக சுத்தம் செய்கிறது.

// இது ஒரு தரவு எடுக்கும் ஹூக்கிலிருந்து வரும் நிலை என்று வைத்துக் கொள்வோம்
const apiState = { status: 'error', error: { code: 403, message: 'Forbidden' } };

function renderUI(state) {
return match(state)
.with({ status: 'loading' }, () => '

')
.with({ status: 'success', data: P.select() }, (users) => `

${users.map(u => `
• ${u.name}
`).join('')}

`)
.with({ status: 'error', error: { code: 404 } }, () => '

Error: The requested resource was not found.

')
.with({ status: 'error', error: P.select() }, (err) => `

An unexpected error occurred: ${err.message}

`)
.exhaustive(); // எங்கள் நிலை வகையின் அனைத்து வழக்குகளும் கையாளப்பட்டுள்ளன என்பதை உறுதி செய்கிறது
}

// document.body.innerHTML = renderUI(apiState);

இது உள்ளமைக்கப்பட்ட if (state.status === 'success') சோதனைகளை விட மிகவும் படிக்கக்கூடியதாகவும் வலுவானதாகவும் உள்ளது.

ஃபங்ஷனல் காம்போனென்ட்களில் ஸ்டேட் மேனேஜ்மென்ட் (எ.கா., ரியாக்ட்)

ரெடக்ஸ் போன்ற ஸ்டேட் மேனேஜ்மென்ட் நூலகங்களில் அல்லது ரியாக்டின் `useReducer` ஹூக்கைப் பயன்படுத்தும்போது, நீங்கள் பெரும்பாலும் பல்வேறு ஆக்ஷன் வகைகளைக் கையாளும் ஒரு ரிட்யூசர் செயல்பாட்டைக் கொண்டிருப்பீர்கள். `action.type` இல் ஒரு `switch` பொதுவானது, ஆனால் முழு `action` ஆப்ஜெக்டிலும் பேட்டர்ன் மேட்சிங் செய்வது உயர்ந்தது.

// முன்பு: ஒரு ஸ்விட்ச் ஸ்டேட்மென்டுடன் ஒரு வழக்கமான ரிட்யூசர்
function classicReducer(state, action) {
switch (action.type) {
case 'INCREMENT':
return { ...state, count: state.count + 1 };
case 'DECREMENT':
return { ...state, count: state.count - 1 };
case 'SET_VALUE':
return { ...state, count: action.payload };
default:
return state;
}
}

// பிறகு: பேட்டர்ன் மேட்சிங்கைப் பயன்படுத்தும் ஒரு ரிட்யூசர்
function patternMatchingReducer(state, action) {
return match(action)
.with({ type: 'INCREMENT' }, () => ({ ...state, count: state.count + 1 }))
.with({ type: 'DECREMENT' }, () => ({ ...state, count: state.count - 1 }))
.with({ type: 'SET_VALUE', payload: P.select() }, (value) => ({ ...state, count: value }))
.otherwise(() => state);
}


பேட்டர்ன் மேட்சிங் பதிப்பு மேலும் டெக்ளரேட்டிவ் ஆகும். இது ஒரு குறிப்பிட்ட ஆக்ஷன் வகைக்கு `action.payload` இல்லாமல் இருக்கலாம் என்பதால் அதை அணுகுவது போன்ற பொதுவான பிழைகளையும் தடுக்கிறது. பேட்டர்ன் தானே `'SET_VALUE'` வழக்குக்கு `payload` இருக்க வேண்டும் என்பதை அமல்படுத்துகிறது.

ஃபைனைட் ஸ்டேட் மெஷின்களை (FSMs) செயல்படுத்துதல்

ஒரு ஃபைனைட் ஸ்டேட் மெஷின் என்பது ஒரு குறிப்பிட்ட எண்ணிக்கையிலான நிலைகளில் ஒன்றில் இருக்கக்கூடிய ஒரு கணக்கீட்டு மாதிரியாகும். இந்த நிலைகளுக்கு இடையிலான மாற்றங்களை வரையறுக்க பேட்டர்ன் மேட்சிங் சரியான கருவியாகும்.

// நிலைகள்: { status: 'idle' } | { status: 'loading' } | { status: 'success', data: T } | { status: 'error', error: E }
// நிகழ்வுகள்: { type: 'FETCH' } | { type: 'RESOLVE', data: T } | { type: 'REJECT', error: E }

function stateMachine(currentState, event) {
return match([currentState, event])
.with([{ status: 'idle' }, { type: 'FETCH' }], () => ({ status: 'loading' }))
.with([{ status: 'loading' }, { type: 'RESOLVE', data: P.select() }], (data) => ({ status: 'success', data }))
.with([{ status: 'loading' }, { type: 'REJECT', error: P.select() }], (error) => ({ status: 'error', error }))
.with([{ status: 'error' }, { type: 'FETCH' }], () => ({ status: 'loading' }))
.otherwise(() => currentState); // மற்ற அனைத்து சேர்க்கைகளுக்கும், தற்போதைய நிலையில் இருங்கள்
}

இந்த அணுகுமுறை சரியான நிலை மாற்றங்களை வெளிப்படையாகவும் மற்றும் பகுத்தறிய எளிதாகவும் ஆக்குகிறது.

குறியீட்டின் தரம் மற்றும் பராமரிப்புக்கான நன்மைகள்

பேட்டர்ன் மேட்சிங்கை ஏற்றுக்கொள்வது புத்திசாலித்தனமான குறியீட்டை எழுதுவது மட்டுமல்ல; இது முழு மென்பொருள் மேம்பாட்டு வாழ்க்கைச் சுழற்சிக்கும் உறுதியான நன்மைகளைக் கொண்டுள்ளது.

• படிக்க எளிதானது & டெக்ளரேட்டிவ் ஸ்டைல்: பேட்டர்ன் மேட்சிங் உங்கள் தரவு என்ன போல் தெரிகிறது என்பதை விவரிக்க உங்களை கட்டாயப்படுத்துகிறது, அதை ஆய்வு செய்வதற்கான இம்பரேட்டிவ் படிகளை அல்ல. இது உங்கள் குறியீட்டின் நோக்கத்தை மற்ற டெவலப்பர்களுக்கு அவர்களின் கலாச்சார அல்லது மொழி பின்னணியைப் பொருட்படுத்தாமல் தெளிவாக்குகிறது.
• இம்யூட்டபிலிட்டி மற்றும் ப்யூர் ஃபங்ஷன்ஸ்: பேட்டர்ன் மேட்சிங்கின் எக்ஸ்பிரஷன்-சார்ந்த தன்மை ஃபங்ஷனல் புரோகிராமிங் கொள்கைகளுடன் சரியாகப் பொருந்துகிறது. இது தரவை எடுத்து, அதை மாற்றி, ஒரு புதிய மதிப்பைத் தருவதற்கு உங்களை ஊக்குவிக்கிறது, நிலையை நேரடியாக மாற்றுவதை விட. இது குறைவான பக்க விளைவுகளுக்கும் மற்றும் மேலும் கணிக்கக்கூடிய குறியீட்டிற்கும் வழிவகுக்கிறது.
• முழுமையான சரிபார்ப்பு (Exhaustiveness Checking): இது நம்பகத்தன்மைக்கு ஒரு கேம்-சேஞ்சர். TypeScript ஐப் பயன்படுத்தும்போது, `ts-pattern` போன்ற நூலகங்கள் நீங்கள் ஒரு யூனியன் வகையின் ஒவ்வொரு சாத்தியமான மாறுபாட்டையும் கையாண்டுள்ளீர்கள் என்பதை கம்பைல் நேரத்தில் அமல்படுத்த முடியும். நீங்கள் ஒரு புதிய நிலை அல்லது ஆக்ஷன் வகையைச் சேர்த்தால், உங்கள் மேட்ச் எக்ஸ்பிரஷனில் அதற்கேற்ப ஒரு ஹேண்ட்லரைச் சேர்க்கும் வரை கம்பைலர் பிழை காட்டும். இந்த எளிய அம்சம் ஒரு முழு வகை ரன்டைம் பிழைகளை நீக்குகிறது.
• குறைக்கப்பட்ட சைக்ளோமேடிக் காம்ப்ளெக்சிட்டி: இது ஆழமாக உள்ளமைக்கப்பட்ட `if/else` கட்டமைப்புகளை ஒரு ஒற்றை, நேரியல் மற்றும் படிக்க எளிதான பிளாக்காக தட்டையாக்குகிறது. குறைந்த சிக்கலான குறியீட்டை சோதிப்பது, பிழைதிருத்தம் செய்வது மற்றும் பராமரிப்பது எளிது.

இன்றே பேட்டர்ன் மேட்சிங்குடன் தொடங்குதல்

இதை முயற்சிக்கத் தயாரா? இதோ ஒரு எளிய, செயல்படுத்தக்கூடிய திட்டம்:

1. உங்கள் கருவியைத் தேர்ந்தெடுக்கவும்: அதன் வலுவான அம்சத் தொகுப்பு மற்றும் சிறந்த TypeScript ஆதரவிற்காக ts-pattern ஐ நாங்கள் மிகவும் பரிந்துரைக்கிறோம். இது இன்று ஜாவாஸ்கிரிப்ட் சூழல் அமைப்பில் தங்கத் தரமாகும்.
2. நிறுவல்: உங்கள் விருப்பமான பேக்கேஜ் மேலாளரைப் பயன்படுத்தி அதை உங்கள் திட்டத்தில் சேர்க்கவும்.
   npm install ts-pattern
   அல்லது
   yarn add ts-pattern
3. ஒரு சிறிய குறியீட்டுப் பகுதியை ரீஃபாக்டர் செய்யவும்: செய்வதன் மூலம் கற்றுக்கொள்வதே சிறந்த வழி. உங்கள் குறியீட்டுத் தளத்தில் ஒரு சிக்கலான `switch` ஸ்டேட்மென்ட் அல்லது ஒரு குழப்பமான `if/else` சங்கிலியைக் கண்டறியவும். இது ப்ராப்ஸ்களின் அடிப்படையில் வெவ்வேறு UI-ஐ வழங்கும் ஒரு காம்போனென்ட், API தரவைப் பிரிக்கும் ஒரு ஃபங்ஷன், அல்லது ஒரு ரிட்யூசராக இருக்கலாம். அதை ரீஃபாக்டர் செய்ய முயற்சிக்கவும்.

செயல்திறன் பற்றிய ஒரு குறிப்பு

பேட்டர்ன் மேட்சிங்கிற்காக ஒரு நூலகத்தைப் பயன்படுத்துவது செயல்திறன் அபராதத்தை ஏற்படுத்துமா என்பது ஒரு பொதுவான கேள்வி. பதில் ஆம், ஆனால் அது கிட்டத்தட்ட எப்போதும் மிகக் குறைவானது. இந்த நூலகங்கள் மிகவும் உகந்ததாக்கப்பட்டுள்ளன, மேலும் பெரும்பாலான வலைப் பயன்பாடுகளுக்கு மேல்நிலை செலவு மிகச் சிறியது. டெவலப்பர் உற்பத்தித்திறன், குறியீட்டுத் தெளிவு, மற்றும் பிழை தடுப்பு ஆகியவற்றில் கிடைக்கும் மகத்தான ஆதாயங்கள் மைக்ரோ விநாடி அளவிலான செயல்திறன் செலவை விட மிக அதிகம். முன்கூட்டியே மேம்படுத்த வேண்டாம்; தெளிவான, சரியான, மற்றும் பராமரிக்கக்கூடிய குறியீட்டை எழுதுவதற்கு முன்னுரிமை அளியுங்கள்.

எதிர்காலம்: ECMAScript-ல் நேட்டிவ் பேட்டர்ன் மேட்சிங்

குறிப்பிட்டபடி, TC39 குழு பேட்டர்ன் மேட்சிங்கை ஒரு நேட்டிவ் அம்சமாகச் சேர்ப்பதில் பணியாற்றி வருகிறது. தொடரியல் இன்னும் விவாதிக்கப்படுகிறது, ஆனால் அது இதுபோன்று இருக்கலாம்:

// சாத்தியமான எதிர்கால தொடரியல்! let httpMessage = match (response) {
when { status: 200, body: b } -> `Success with body: ${b}`,
when { status: 404 } -> `Not Found`,
when { status: 5.. } -> `Server Error`,
else -> `Other HTTP response`
};

ts-pattern போன்ற நூலகங்களுடன் இன்று கருத்துக்களையும் பேட்டர்ன்களையும் கற்றுக்கொள்வதன் மூலம், உங்கள் தற்போதைய திட்டங்களை மேம்படுத்துவது மட்டுமல்லாமல்; நீங்கள் ஜாவாஸ்கிரிப்ட் மொழியின் எதிர்காலத்திற்கும் தயாராகிறீர்கள். நீங்கள் உருவாக்கும் மன மாதிரிகள் இந்த அம்சங்கள் நேட்டிவ் ஆகும்போது நேரடியாக மொழிபெயர்க்கப்படும்.

முடிவுரை: ஜாவாஸ்கிரிப்ட் நிபந்தனைகளுக்கான ஒரு முன்னுதாரண மாற்றம்

பேட்டர்ன் மேட்சிங் என்பது switch ஸ்டேட்மென்டுக்கான தொடரியல் சர்க்கரையை விட மிக அதிகம். இது ஜாவாஸ்கிரிப்டில் நிபந்தனை தர்க்கத்தைக் கையாள்வதில் ஒரு மேலும் டெக்ளரேட்டிவ், வலுவான, மற்றும் ஃபங்ஷனல் பாணியை நோக்கிய ஒரு அடிப்படை மாற்றத்தைக் குறிக்கிறது. இது உங்கள் தரவின் வடிவத்தைப் பற்றி சிந்திக்க உங்களை ஊக்குவிக்கிறது, இது மிகவும் நேர்த்தியானது மட்டுமல்லாமல், பிழைகளுக்கு அதிக எதிர்ப்புத் திறன் கொண்டதாகவும் காலப்போக்கில் பராமரிக்க எளிதாகவும் இருக்கும் குறியீட்டிற்கு வழிவகுக்கிறது.

உலகெங்கிலும் உள்ள மேம்பாட்டுக் குழுக்களுக்கு, பேட்டர்ன் மேட்சிங்கை ஏற்றுக்கொள்வது ஒரு மேலும் நிலையான மற்றும் வெளிப்படையான குறியீட்டுத் தளத்திற்கு வழிவகுக்கும். இது நமது பாரம்பரிய கருவிகளின் எளிய சோதனைகளைத் தாண்டிய சிக்கலான தரவு கட்டமைப்புகளைக் கையாள்வதற்கான ஒரு பொதுவான மொழியை வழங்குகிறது. உங்கள் அடுத்த திட்டத்தில் அதை ஆராய நாங்கள் உங்களை ஊக்குவிக்கிறோம். சிறியதாகத் தொடங்குங்கள், ஒரு சிக்கலான ஃபங்ஷனை ரீஃபாக்டர் செய்யுங்கள், மேலும் அது உங்கள் குறியீட்டிற்கு கொண்டு வரும் தெளிவையும் சக்தியையும் அனுபவியுங்கள்.